home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / usb / serial.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  12.6 KB  |  331 lines
  1. /*
  2.  * USB Serial Converter stuff
  3.  *
  4.  *    Copyright (C) 1999 - 2005
  5.  *        Greg Kroah-Hartman (greg@kroah.com)
  6.  *
  7.  *    This program is free software; you can redistribute it and/or modify
  8.  *    it under the terms of the GNU General Public License as published by
  9.  *    the Free Software Foundation; version 2 of the License.
  10.  *
  11.  */
  12.  
  13. #ifndef __LINUX_USB_SERIAL_H
  14. #define __LINUX_USB_SERIAL_H
  15.  
  16. #include <linux/kref.h>
  17. #include <linux/mutex.h>
  18.  
  19. #define SERIAL_TTY_MAJOR    188    /* Nice legal number now */
  20. #define SERIAL_TTY_MINORS    254    /* loads of devices :) */
  21. #define SERIAL_TTY_NO_MINOR    255    /* No minor was assigned */
  22.  
  23. /* The maximum number of ports one device can grab at once */
  24. #define MAX_NUM_PORTS        8
  25.  
  26. /* parity check flag */
  27. #define RELEVANT_IFLAG(iflag)    (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
  28.  
  29. /**
  30.  * usb_serial_port: structure for the specific ports of a device.
  31.  * @serial: pointer back to the struct usb_serial owner of this port.
  32.  * @tty: pointer to the corresponding tty for this port.
  33.  * @lock: spinlock to grab when updating portions of this structure.
  34.  * @mutex: mutex used to synchronize serial_open() and serial_close()
  35.  *    access for this port.
  36.  * @number: the number of the port (the minor number).
  37.  * @interrupt_in_buffer: pointer to the interrupt in buffer for this port.
  38.  * @interrupt_in_urb: pointer to the interrupt in struct urb for this port.
  39.  * @interrupt_in_endpointAddress: endpoint address for the interrupt in pipe
  40.  *    for this port.
  41.  * @interrupt_out_buffer: pointer to the interrupt out buffer for this port.
  42.  * @interrupt_out_size: the size of the interrupt_out_buffer, in bytes.
  43.  * @interrupt_out_urb: pointer to the interrupt out struct urb for this port.
  44.  * @interrupt_out_endpointAddress: endpoint address for the interrupt out pipe
  45.  *     for this port.
  46.  * @bulk_in_buffer: pointer to the bulk in buffer for this port.
  47.  * @read_urb: pointer to the bulk in struct urb for this port.
  48.  * @bulk_in_endpointAddress: endpoint address for the bulk in pipe for this
  49.  *    port.
  50.  * @bulk_out_buffer: pointer to the bulk out buffer for this port.
  51.  * @bulk_out_size: the size of the bulk_out_buffer, in bytes.
  52.  * @write_urb: pointer to the bulk out struct urb for this port.
  53.  * @bulk_out_endpointAddress: endpoint address for the bulk out pipe for this
  54.  *    port.
  55.  * @write_wait: a wait_queue_head_t used by the port.
  56.  * @work: work queue entry for the line discipline waking up.
  57.  * @open_count: number of times this port has been opened.
  58.  * @throttled: nonzero if the read urb is inactive to throttle the device
  59.  * @throttle_req: nonzero if the tty wants to throttle us
  60.  *
  61.  * This structure is used by the usb-serial core and drivers for the specific
  62.  * ports of a device.
  63.  */
  64. struct usb_serial_port {
  65.     struct usb_serial    *serial;
  66.     struct tty_port        port;
  67.     spinlock_t        lock;
  68.     struct mutex            mutex;
  69.     unsigned char        number;
  70.  
  71.     unsigned char        *interrupt_in_buffer;
  72.     struct urb        *interrupt_in_urb;
  73.     __u8            interrupt_in_endpointAddress;
  74.  
  75.     unsigned char        *interrupt_out_buffer;
  76.     int            interrupt_out_size;
  77.     struct urb        *interrupt_out_urb;
  78.     __u8            interrupt_out_endpointAddress;
  79.  
  80.     unsigned char        *bulk_in_buffer;
  81.     int            bulk_in_size;
  82.     struct urb        *read_urb;
  83.     __u8            bulk_in_endpointAddress;
  84.  
  85.     unsigned char        *bulk_out_buffer;
  86.     int            bulk_out_size;
  87.     struct urb        *write_urb;
  88.     int            write_urb_busy;
  89.     __u8            bulk_out_endpointAddress;
  90.  
  91.     wait_queue_head_t    write_wait;
  92.     struct work_struct    work;
  93.     char            throttled;
  94.     char            throttle_req;
  95.     char            console;
  96.     struct device        dev;
  97. };
  98. #define to_usb_serial_port(d) container_of(d, struct usb_serial_port, dev)
  99.  
  100. /* get and set the port private data pointer helper functions */
  101. static inline void *usb_get_serial_port_data(struct usb_serial_port *port)
  102. {
  103.     return dev_get_drvdata(&port->dev);
  104. }
  105.  
  106. static inline void usb_set_serial_port_data(struct usb_serial_port *port,
  107.                         void *data)
  108. {
  109.     dev_set_drvdata(&port->dev, data);
  110. }
  111.  
  112. /**
  113.  * usb_serial - structure used by the usb-serial core for a device
  114.  * @dev: pointer to the struct usb_device for this device
  115.  * @type: pointer to the struct usb_serial_driver for this device
  116.  * @interface: pointer to the struct usb_interface for this device
  117.  * @minor: the starting minor number for this device
  118.  * @num_ports: the number of ports this device has
  119.  * @num_interrupt_in: number of interrupt in endpoints we have
  120.  * @num_interrupt_out: number of interrupt out endpoints we have
  121.  * @num_bulk_in: number of bulk in endpoints we have
  122.  * @num_bulk_out: number of bulk out endpoints we have
  123.  * @port: array of struct usb_serial_port structures for the different ports.
  124.  * @private: place to put any driver specific information that is needed.  The
  125.  *    usb-serial driver is required to manage this data, the usb-serial core
  126.  *    will not touch this.  Use usb_get_serial_data() and
  127.  *    usb_set_serial_data() to access this.
  128.  */
  129. struct usb_serial {
  130.     struct usb_device        *dev;
  131.     struct usb_serial_driver    *type;
  132.     struct usb_interface        *interface;
  133.     unsigned char            disconnected;
  134.     unsigned char            minor;
  135.     unsigned char            num_ports;
  136.     unsigned char            num_port_pointers;
  137.     char                num_interrupt_in;
  138.     char                num_interrupt_out;
  139.     char                num_bulk_in;
  140.     char                num_bulk_out;
  141.     struct usb_serial_port        *port[MAX_NUM_PORTS];
  142.     struct kref            kref;
  143.     struct mutex            disc_mutex;
  144.     void                *private;
  145. };
  146. #define to_usb_serial(d) container_of(d, struct usb_serial, kref)
  147.  
  148. /* get and set the serial private data pointer helper functions */
  149. static inline void *usb_get_serial_data(struct usb_serial *serial)
  150. {
  151.     return serial->private;
  152. }
  153.  
  154. static inline void usb_set_serial_data(struct usb_serial *serial, void *data)
  155. {
  156.     serial->private = data;
  157. }
  158.  
  159. /**
  160.  * usb_serial_driver - describes a usb serial driver
  161.  * @description: pointer to a string that describes this driver.  This string
  162.  *    used in the syslog messages when a device is inserted or removed.
  163.  * @id_table: pointer to a list of usb_device_id structures that define all
  164.  *    of the devices this structure can support.
  165.  * @num_ports: the number of different ports this device will have.
  166.  * @calc_num_ports: pointer to a function to determine how many ports this
  167.  *    device has dynamically.  It will be called after the probe()
  168.  *    callback is called, but before attach()
  169.  * @probe: pointer to the driver's probe function.
  170.  *    This will be called when the device is inserted into the system,
  171.  *    but before the device has been fully initialized by the usb_serial
  172.  *    subsystem.  Use this function to download any firmware to the device,
  173.  *    or any other early initialization that might be needed.
  174.  *    Return 0 to continue on with the initialization sequence.  Anything
  175.  *    else will abort it.
  176.  * @attach: pointer to the driver's attach function.
  177.  *    This will be called when the struct usb_serial structure is fully set
  178.  *    set up.  Do any local initialization of the device, or any private
  179.  *    memory structure allocation at this point in time.
  180.  * @shutdown: pointer to the driver's shutdown function.  This will be
  181.  *    called when the device is removed from the system.
  182.  * @usb_driver: pointer to the struct usb_driver that controls this
  183.  *    device.  This is necessary to allow dynamic ids to be added to
  184.  *    the driver from sysfs.
  185.  *
  186.  * This structure is defines a USB Serial driver.  It provides all of
  187.  * the information that the USB serial core code needs.  If the function
  188.  * pointers are defined, then the USB serial core code will call them when
  189.  * the corresponding tty port functions are called.  If they are not
  190.  * called, the generic serial function will be used instead.
  191.  *
  192.  * The driver.owner field should be set to the module owner of this driver.
  193.  * The driver.name field should be set to the name of this driver (remember
  194.  * it will show up in sysfs, so it needs to be short and to the point.
  195.  * Using the module name is a good idea.)
  196.  */
  197. struct usb_serial_driver {
  198.     const char *description;
  199.     const struct usb_device_id *id_table;
  200.     char    num_ports;
  201.  
  202.     struct list_head    driver_list;
  203.     struct device_driver    driver;
  204.     struct usb_driver    *usb_driver;
  205.     struct usb_dynids    dynids;
  206.  
  207.     int (*probe)(struct usb_serial *serial, const struct usb_device_id *id);
  208.     int (*attach)(struct usb_serial *serial);
  209.     int (*calc_num_ports) (struct usb_serial *serial);
  210.  
  211.     void (*shutdown)(struct usb_serial *serial);
  212.  
  213.     int (*port_probe)(struct usb_serial_port *port);
  214.     int (*port_remove)(struct usb_serial_port *port);
  215.  
  216.     int (*suspend)(struct usb_serial *serial, pm_message_t message);
  217.     int (*resume)(struct usb_serial *serial);
  218.  
  219.     /* serial function calls */
  220.     /* Called by console with tty = NULL and by tty */
  221.     int  (*open)(struct tty_struct *tty,
  222.             struct usb_serial_port *port, struct file *filp);
  223.     void (*close)(struct tty_struct *tty,
  224.             struct usb_serial_port *port, struct file *filp);
  225.     int  (*write)(struct tty_struct *tty, struct usb_serial_port *port,
  226.             const unsigned char *buf, int count);
  227.     /* Called only by the tty layer */
  228.     int  (*write_room)(struct tty_struct *tty);
  229.     int  (*ioctl)(struct tty_struct *tty, struct file *file,
  230.               unsigned int cmd, unsigned long arg);
  231.     void (*set_termios)(struct tty_struct *tty,
  232.             struct usb_serial_port *port, struct ktermios *old);
  233.     void (*break_ctl)(struct tty_struct *tty, int break_state);
  234.     int  (*chars_in_buffer)(struct tty_struct *tty);
  235.     void (*throttle)(struct tty_struct *tty);
  236.     void (*unthrottle)(struct tty_struct *tty);
  237.     int  (*tiocmget)(struct tty_struct *tty, struct file *file);
  238.     int  (*tiocmset)(struct tty_struct *tty, struct file *file,
  239.              unsigned int set, unsigned int clear);
  240.     /* USB events */
  241.     void (*read_int_callback)(struct urb *urb);
  242.     void (*write_int_callback)(struct urb *urb);
  243.     void (*read_bulk_callback)(struct urb *urb);
  244.     void (*write_bulk_callback)(struct urb *urb);
  245. };
  246. #define to_usb_serial_driver(d) \
  247.     container_of(d, struct usb_serial_driver, driver)
  248.  
  249. extern int  usb_serial_register(struct usb_serial_driver *driver);
  250. extern void usb_serial_deregister(struct usb_serial_driver *driver);
  251. extern void usb_serial_port_softint(struct usb_serial_port *port);
  252.  
  253. extern int usb_serial_probe(struct usb_interface *iface,
  254.                 const struct usb_device_id *id);
  255. extern void usb_serial_disconnect(struct usb_interface *iface);
  256.  
  257. extern int usb_serial_suspend(struct usb_interface *intf, pm_message_t message);
  258. extern int usb_serial_resume(struct usb_interface *intf);
  259.  
  260. extern int ezusb_writememory(struct usb_serial *serial, int address,
  261.                  unsigned char *data, int length, __u8 bRequest);
  262. extern int ezusb_set_reset(struct usb_serial *serial, unsigned char reset_bit);
  263.  
  264. /* USB Serial console functions */
  265. #ifdef CONFIG_USB_SERIAL_CONSOLE
  266. extern void usb_serial_console_init(int debug, int minor);
  267. extern void usb_serial_console_exit(void);
  268. extern void usb_serial_console_disconnect(struct usb_serial *serial);
  269. #else
  270. static inline void usb_serial_console_init(int debug, int minor) { }
  271. static inline void usb_serial_console_exit(void) { }
  272. static inline void usb_serial_console_disconnect(struct usb_serial *serial) {}
  273. #endif
  274.  
  275. /* Functions needed by other parts of the usbserial core */
  276. extern struct usb_serial *usb_serial_get_by_index(unsigned int minor);
  277. extern void usb_serial_put(struct usb_serial *serial);
  278. extern int usb_serial_generic_open(struct tty_struct *tty,
  279.         struct usb_serial_port *port, struct file *filp);
  280. extern int usb_serial_generic_write(struct tty_struct *tty,
  281.     struct usb_serial_port *port, const unsigned char *buf, int count);
  282. extern void usb_serial_generic_close(struct tty_struct *tty,
  283.             struct usb_serial_port *port, struct file *filp);
  284. extern int usb_serial_generic_resume(struct usb_serial *serial);
  285. extern int usb_serial_generic_write_room(struct tty_struct *tty);
  286. extern int usb_serial_generic_chars_in_buffer(struct tty_struct *tty);
  287. extern void usb_serial_generic_read_bulk_callback(struct urb *urb);
  288. extern void usb_serial_generic_write_bulk_callback(struct urb *urb);
  289. extern void usb_serial_generic_throttle(struct tty_struct *tty);
  290. extern void usb_serial_generic_unthrottle(struct tty_struct *tty);
  291. extern void usb_serial_generic_shutdown(struct usb_serial *serial);
  292. extern int usb_serial_generic_register(int debug);
  293. extern void usb_serial_generic_deregister(void);
  294.  
  295. extern int usb_serial_bus_register(struct usb_serial_driver *device);
  296. extern void usb_serial_bus_deregister(struct usb_serial_driver *device);
  297.  
  298. extern struct usb_serial_driver usb_serial_generic_device;
  299. extern struct bus_type usb_serial_bus_type;
  300. extern struct tty_driver *usb_serial_tty_driver;
  301.  
  302. static inline void usb_serial_debug_data(int debug,
  303.                      struct device *dev,
  304.                      const char *function, int size,
  305.                      const unsigned char *data)
  306. {
  307.     int i;
  308.  
  309.     if (debug) {
  310.         dev_printk(KERN_DEBUG, dev, "%s - length = %d, data = ",
  311.                function, size);
  312.         for (i = 0; i < size; ++i)
  313.             printk("%.2x ", data[i]);
  314.         printk("\n");
  315.     }
  316. }
  317.  
  318. /* Use our own dbg macro */
  319. #undef dbg
  320. #define dbg(format, arg...) \
  321.     do { \
  322.         if (debug) \
  323.             printk(KERN_DEBUG "%s: " format "\n" , __FILE__ , \
  324.                 ## arg); \
  325.     } while (0)
  326.  
  327.  
  328.  
  329. #endif /* __LINUX_USB_SERIAL_H */
  330.  
  331.